package com.ruoyi.common.utils;

import com.ruoyi.common.core.domain.entity.SysRole;
import com.ruoyi.common.core.domain.entity.SysUser;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import com.ruoyi.common.constant.HttpStatus;
import com.ruoyi.common.core.domain.model.LoginUser;
import com.ruoyi.common.exception.CustomException;

import java.util.List;

/**
 * 安全服务工具类
 * 
 * @author ruoyi
 */
public class SecurityUtils
{
    /**
     * 获取用户账户
     **/
    public static String getUsername()
    {
        try
        {
            return getLoginUser().getUsername();
        }
        catch (Exception e)
        {
            throw new CustomException("获取用户账户异常", HttpStatus.UNAUTHORIZED);
        }
    }

    /**
     * 获取用户
     **/
    public static LoginUser getLoginUser()
    {
        try
        {
            return (LoginUser) getAuthentication().getPrincipal();
        }
        catch (Exception e)
        {
            throw new CustomException("获取用户信息异常", HttpStatus.UNAUTHORIZED);
        }
    }

    /**
     * 获取Authentication
     */
    public static Authentication getAuthentication()
    {
        return SecurityContextHolder.getContext().getAuthentication();
    }

    /**
     * 生成BCryptPasswordEncoder密码
     *
     * @param password 密码
     * @return 加密字符串
     */
    public static String encryptPassword(String password)
    {
        BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
        return passwordEncoder.encode(password);
    }

    /**
     * 判断密码是否相同
     *
     * @param rawPassword 真实密码
     * @param encodedPassword 加密后字符
     * @return 结果
     */
    public static boolean matchesPassword(String rawPassword, String encodedPassword)
    {
        BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
        return passwordEncoder.matches(rawPassword, encodedPassword);
    }

    /**
     * 是否为管理员
     *
     * @param roleName 角色名
     * @return 结果
     */
    public static boolean isPlatformAdmin(String roleName)
    {
        return roleName != null && roleName.equals("PT_ADMIN");
    }


    /**
     * 是否为平台管理员
     *
     * @param user 用户
     * @return 结果
     * @return 结果
     */
    public static boolean isPlatformAdmin(SysUser user)
    {
        List<SysRole> roles=user.getRoles();
        boolean platformAdmin=false;
        if(roles!=null&&roles.size()>0){
            for (SysRole role:  roles) {
                if(role.getRoleKey().equals("PT_ADMIN")){
                    platformAdmin=true;
                    break;
                }
            }
        }
        return platformAdmin;
    }

    /**
     * 是否为超级管理员
     *
     * @param role 角色
     * @return 结果
     * @return 结果
     */
    public static boolean isPlatformAdmin(SysRole role)
    {

        boolean platformAdmin=false;
        if(role.getRoleKey().equals("PT_ADMIN")){
            platformAdmin=true;
        }
        return platformAdmin;
    }

    /**
     * 是否为超级管理员
     *
     * @param user 用户
     * @return 结果
     * @return 结果
     */
    public static boolean isSuperAdmin(SysUser user)
    {
        List<SysRole> roles=user.getRoles();
        boolean superAdmin=false;
        if(roles!=null&&roles.size()>0){
            for (SysRole role:  roles) {
                if(role.getRoleKey().equals("SUPER_ADMIN")){
                    superAdmin=true;
                    break;
                }
            }
        }
        return superAdmin;
    }


    /**
     * 是否为超级管理员
     *
     * @param role 角色
     * @return 结果
     * @return 结果
     */
    public static boolean isSuperAdmin(SysRole role)
    {

        boolean superAdmin=false;
        if(role.getRoleKey().equals("SUPER_ADMIN")){
            superAdmin=true;
        }
        return superAdmin;
    }


}
